home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-15 / vesakb.zip / VESAKB.C < prev    next >
C/C++ Source or Header  |  1992-04-30  |  12KB  |  400 lines
  1. #include <dos.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4.  
  5. #pragma pack(1)
  6.  
  7. /****************************************
  8. *   Register definitions                *
  9. ****************************************/
  10. union   REGS    Regs;
  11. struct  SREGS   SRegs;
  12.  
  13. #define AX      Regs.x.ax
  14. #define BX      Regs.x.bx
  15. #define CX      Regs.x.cx
  16. #define DX      Regs.x.dx
  17. #define SI      Regs.x.si
  18. #define DI      Regs.x.di
  19.  
  20. #define AH      Regs.h.ah
  21. #define AL      Regs.h.al
  22. #define BH      Regs.h.bh
  23. #define BL      Regs.h.bl
  24. #define CH      Regs.h.ch
  25. #define CL      Regs.h.cl
  26. #define DH      Regs.h.dh
  27. #define DL      Regs.h.dl
  28.  
  29. #define CY      Regs.cflag
  30.  
  31. #define CS      SRegs.cs
  32. #define DS      SRegs.ds
  33. #define ES      SRegs.es
  34. #define SS      SRegs.ss
  35.  
  36. /****************************************
  37. *   VESA function definitions           *
  38. ****************************************/
  39. #define GetInfo             0
  40. #define GetModeInfo         1
  41. #define SetMode             2
  42. #define GetMode             3
  43. #define SaveRestoreState    4
  44. #define GetSetRAMWindow     5
  45.  
  46. /****************************************
  47. *   VESA subfunction definitions        *
  48. ****************************************/
  49. #define GetStateBufferSize  0
  50. #define SaveState           1
  51. #define RestoreState        2
  52. #define SetWindow           0
  53. #define GetWindow           1
  54.  
  55. /****************************************
  56. *   VESA information structure          *
  57. ****************************************/
  58. struct VESAInfo
  59. {
  60.     unsigned char           Signature[4];
  61.     unsigned int            VESAVersion;
  62.     unsigned char far *     OEMString;
  63.     unsigned char           Capabilities[4];
  64.     unsigned int far *      ModeList;
  65.     unsigned char           Reserved[238];
  66. };
  67. typedef struct VESAInfo *       VESAInfoPtr;
  68.  
  69. /****************************************
  70. *   VESA mode information structure     *
  71. ****************************************/
  72. struct VESAModeInfo
  73. {
  74.     unsigned int            ModeAttributes;
  75.     unsigned char           WindowAAttributes;
  76.     unsigned char           WindowBAttributes;
  77.     unsigned int            WindowGranularity;
  78.     unsigned int            WindowSize;
  79.     unsigned int            WindowASegment;
  80.     unsigned int            WindowBSegment;
  81.     void (far *             SelectWindow)(void);
  82.     unsigned int            BytesPerScanLine;
  83.  
  84.     unsigned int            WidthInPixels;
  85.     unsigned int            HeightInPixels;
  86.     unsigned char           CharacterWidthInPixels;
  87.     unsigned char           CharacterHeightInPixels;
  88.     unsigned char           Planes;
  89.     unsigned char           BitsPerPixel;
  90.     unsigned char           Banks;
  91.     unsigned char           MemoryModel;
  92.     unsigned char           BankSize;
  93.     unsigned char           Reserved[227];
  94. };
  95. typedef struct VESAModeInfo *   VESAModeInfoPtr;
  96.  
  97. /****************************************
  98. *   Mode attributes                     *
  99. ****************************************/
  100. #define ModeSupported       0x0001
  101. #define OptionalInfo        0x0002
  102. #define BIOSOutputSupport   0x0004
  103. #define ColorMode           0x0008
  104. #define GraphicsMode        0x0010
  105.  
  106. /****************************************
  107. *   Window attributes                   *
  108. ****************************************/
  109. #define WindowSupported     0x0001
  110. #define WindowIsReadable    0x0002
  111. #define WindowIsWritable    0x0004
  112.  
  113. /****************************************
  114. *   VESA modes                          *
  115. ****************************************/
  116. #define Mode640by400by256   0x0100
  117. #define Mode640by480by256   0x0101
  118. #define Mode800by600by16    0x0102
  119. #define Mode800by600by256   0x0103
  120. #define Mode1024by768by16   0x0104
  121. #define Mode1024by768by256  0x0105
  122. #define Mode1280by1024by16  0x0106
  123. #define Mode1280by1024by256 0x0107
  124.  
  125. /****************************************
  126. *   Mode test information structure     *
  127. ****************************************/
  128. struct ModeTest
  129. {
  130.     unsigned int            Mode;
  131.     unsigned int            Width;
  132.     unsigned int            Height;
  133.     unsigned int            Depth;
  134.     unsigned int            KB;
  135. };
  136.  
  137. /****************************************
  138. *   Send VESA interrupt                 *
  139. ****************************************/
  140.  
  141. void intVESA(int Function)
  142. {
  143.     AL = Function;
  144.     AH = 0x4f;
  145.     int86x(0x10, &Regs, &Regs, &SRegs);
  146. }
  147.  
  148. /****************************************
  149. *   Select RAM window                   *
  150. ****************************************/
  151.  
  152. int SelectRAMWindow(int Window, int Page)
  153. {
  154.     BH = SetWindow;
  155.     BL = Window;
  156.     DX = Page;
  157.     intVESA(GetSetRAMWindow);
  158.     return !((int)((unsigned int)AH));
  159. }
  160.  
  161. /****************************************
  162. *   Get VESA information                *
  163. ****************************************/
  164. void GetVESAInformation(VESAInfoPtr Info)
  165. {
  166.     segread(&SRegs);
  167.     ES = DS;
  168.     DI = (unsigned int)Info;
  169.     intVESA(GetInfo);                           // Get VESA information
  170.     if  (   (AL != 0x4f) ||
  171.             (AH != 0) ||
  172.             (strncmp(Info -> Signature, "VESA", 4) != 0)
  173.         )
  174.     {
  175.         puts("Video interface does not support VESA calls.");
  176.         exit(15);
  177.     }
  178. };
  179.  
  180. /****************************************
  181. *   Test RAM                            *
  182. ****************************************/
  183. unsigned int TestRAM(unsigned int Mode, VESAModeInfoPtr ModeInfo)
  184. {
  185.     unsigned int        AUsed           = 0;
  186.     unsigned int        BUsed           = 0;
  187.     unsigned int        WriteWindow;
  188.     unsigned int        ReadWindow;
  189.     unsigned int        Interval;
  190.     unsigned int        Granularity;
  191.     unsigned int        RAMSize;
  192.     unsigned int        WindowSet;
  193.     unsigned char far * WritePtr;
  194.     unsigned char far * ReadPtr;
  195.     unsigned int        Done            = 0;
  196.  
  197.     if ((ModeInfo -> WindowAAttributes & WindowSupported) != 0)
  198.     {
  199.         if ((ModeInfo -> WindowAAttributes & WindowIsReadable) != 0)
  200.         {
  201.             AUsed = 1;
  202.             ReadWindow = 0;
  203.             FP_SEG(ReadPtr) = ModeInfo -> WindowASegment;
  204.         }
  205.         if ((ModeInfo -> WindowAAttributes & WindowIsWritable) != 0)
  206.         {
  207.             AUsed = 1;
  208.             WriteWindow = 0;
  209.             FP_SEG(WritePtr) = ModeInfo -> WindowASegment;
  210.         }
  211.     }
  212.     if ((ModeInfo -> WindowBAttributes & WindowSupported) != 0)
  213.     {
  214.         if ((ModeInfo -> WindowBAttributes & WindowIsReadable) != 0)
  215.         {
  216.             BUsed = 1;
  217.             ReadWindow = 1;
  218.             FP_SEG(ReadPtr) = ModeInfo -> WindowBSegment;
  219.         }
  220.         if ((ModeInfo -> WindowBAttributes & WindowIsWritable) != 0)
  221.         {
  222.             BUsed = 1;
  223.             WriteWindow = 1;
  224.             FP_SEG(WritePtr) = ModeInfo -> WindowBSegment;
  225.         }
  226.     }
  227.     FP_OFF(ReadPtr) = 0;
  228.     FP_OFF(WritePtr) = 0;
  229.     BX = Mode;
  230.     intVESA(SetMode);
  231.     if (AH != 0)
  232.     {
  233.         return 0;
  234.     }
  235.     Granularity = ModeInfo -> WindowGranularity;
  236.     Interval = ModeInfo -> WindowSize / Granularity;
  237.     RAMSize = 0;
  238.     do
  239.     {
  240.         if (AUsed)
  241.         {
  242.             WindowSet = SelectRAMWindow(0, RAMSize);
  243.             if (!WindowSet) Done = 1;
  244.         }
  245.         if (BUsed)
  246.         {
  247.             WindowSet = SelectRAMWindow(1, RAMSize);
  248.             if (!WindowSet) Done |= 1;
  249.         }
  250.         if (*ReadPtr == 0xaa) Done = 1;
  251.         else
  252.         {
  253.             *WritePtr = 0xaa;
  254.             if (*ReadPtr != 0xaa) Done = 1;
  255.             else RAMSize += Interval;
  256.         }
  257.     } while (!Done);
  258.     RAMSize *= Granularity;
  259.     return RAMSize;
  260. }
  261.  
  262. /****************************************
  263. *   Test VESA Mode                      *
  264. ****************************************/
  265. void TestMode(struct ModeTest * ModeTestInfo)
  266. {
  267.     unsigned int        Mode = ModeTestInfo -> Mode;
  268.     struct VESAModeInfo ModeInfo;
  269.  
  270.     segread(&SRegs);
  271.     CX = Mode;
  272.     ES = DS;
  273.     DI = (unsigned int)&ModeInfo;
  274.     intVESA(GetModeInfo);
  275.     if (AH != 0)
  276.     {
  277.         ModeTestInfo -> Width = 0;
  278.         ModeTestInfo -> Height = 0;
  279.         ModeTestInfo -> Depth = 0;
  280.         ModeTestInfo -> KB = 0;
  281.     }
  282.     else if ((ModeInfo.ModeAttributes & OptionalInfo) == 0)
  283.     {
  284.         switch ((Mode & 7) >> 1)
  285.         {
  286.             case    0:
  287.                 ModeTestInfo -> Width = 640;
  288.                 ModeTestInfo -> Height = ((Mode & 1) == 0) ? 400 : 480;
  289.                 ModeTestInfo -> Depth = 256;
  290.                 break;
  291.             case    1:
  292.                 ModeTestInfo -> Width = 800;
  293.                 ModeTestInfo -> Height = 600;
  294.                 ModeTestInfo -> Depth = ((Mode & 1) == 0) ? 16 : 256;
  295.                 break;
  296.             case    2:
  297.                 ModeTestInfo -> Width = 1024;
  298.                 ModeTestInfo -> Height = 768;
  299.                 ModeTestInfo -> Depth = ((Mode & 1) == 0) ? 16 : 256;
  300.                 break;
  301.             case    3:
  302.                 ModeTestInfo -> Width = 1280;
  303.                 ModeTestInfo -> Height = 1024;
  304.                 ModeTestInfo -> Depth = ((Mode & 1) == 0) ? 16 : 256;
  305.                 break;
  306.         }
  307.         ModeTestInfo -> KB = TestRAM(Mode, &ModeInfo);
  308.     }
  309.     else
  310.     {
  311.         ModeTestInfo -> Width = ModeInfo.WidthInPixels;
  312.         ModeTestInfo -> Height = ModeInfo.HeightInPixels;
  313.         ModeTestInfo -> Depth = 1 << ModeInfo.BitsPerPixel;
  314.         ModeTestInfo -> KB = TestRAM(Mode, &ModeInfo);
  315.     }
  316. }
  317.  
  318. /****************************************
  319. *   Main                                *
  320. ****************************************/
  321.  
  322. void main(void)
  323. {
  324.     char                Buf[16];
  325.     int                 i;
  326.     int                 ModeCnt         = 0;
  327.     int                 ErrorFlag       = 0;
  328.     unsigned int        CurrentMode;
  329.     unsigned int far *  ModePtr;
  330.     struct VESAInfo     Info;
  331.     struct ModeTest     ModeTestInfo[16];
  332.  
  333.     GetVESAInformation(&Info);
  334.     ModePtr = Info.ModeList;
  335.     while (*ModePtr != -1)
  336.     {
  337.         ModeTestInfo[ModeCnt++].Mode = *ModePtr++;
  338.     }
  339.     if (ModeCnt == 0)
  340.     {
  341.         puts("No VESA modes supported.");
  342.         exit(15);
  343.     }
  344.     intVESA(GetMode);
  345.     if (AH != 0)
  346.     {
  347.         puts("Cannot get current video mode.");
  348.         exit(15);
  349.     }
  350.     CurrentMode = BX;
  351.     for (i = 0; i < ModeCnt; i++)
  352.     {
  353.         TestMode(&ModeTestInfo[i]);
  354.     }
  355.     BX = CurrentMode;
  356.     intVESA(SetMode);
  357.     puts("Video interface supports VESA calls.");
  358.     printf("OEM string = %Fs\n\n", Info.OEMString);
  359.     puts("Mode (hex)      Resolution (WxHxD)      Video RAM (KB)");
  360.     for (i = 0; i < ModeCnt; i++)
  361.     {
  362.         printf("   %04x", ModeTestInfo[i].Mode);
  363.         if (ModeTestInfo[i].Width == 0)
  364.         {
  365.             puts("*");
  366.             ErrorFlag = 1;
  367.         }
  368.         else
  369.         {
  370.             sprintf
  371.                 (   Buf,
  372.                     "%dx%dx%d",
  373.                     ModeTestInfo[i].Width,
  374.                     ModeTestInfo[i].Height,
  375.                     ModeTestInfo[i].Depth
  376.                 );
  377.             if (ModeTestInfo[i].KB != 0)
  378.             {
  379.                 printf
  380.                     (   "           %-13s              %d\n",
  381.                         Buf,
  382.                         ModeTestInfo[i].KB
  383.                     );
  384.             }
  385.             else
  386.             {
  387.                 printf
  388.                     (   "           %-13s              *\n",
  389.                         Buf
  390.                     );
  391.                 ErrorFlag = 1;
  392.             }
  393.         }
  394.     }
  395.     if (ErrorFlag)
  396.     {
  397.         puts("\n* indicates unavailable information.");
  398.     }
  399. }
  400.